Before the rise of modern enterprise software architecture, business systems were typically implemented as a single monolithic piece of software, responsible for processing all functions of the business. This practice resulted in “information silos” that were inflexible, costly to maintain, and most importantly, difficult to re-use. The desire for software re-use led to component-based and, later, service-based architecture which decomposed monolithic software systems into more cohesive units. While leveraging existing software assets has led to increased development efficiency, an important side-effect has been an increase in testing complexity. It is no longer sufficient to simply test the monolithic system in isolation with distributed components—it has become necessary to test at several stages, each at a successively higher level of abstraction. For example:                unit level—testing individual components or subcomponents to verify correct behavior in isolation.        integration level—testing a number of components together, but in isolation from the rest of the system, in order to verify that they communicate together correctly        system level—testing the entire (complete) system of components together to verify the correct holistic behavior of the application.        
The tasks of integration and system level testing become increasingly complex because of the heterogeneous components and protocols involved. The typical enterprise application will often employ a database system, a layer of business logic, a messaging bus to communicate asynchronously with other components and services, a presentation layer for users to interact with the system, and any number of middle layers to integrate the numerous components. Because a software tester may not have direct control over any (or all) of these components or subcomponents, a problem of how to create a realistic environment for the system under test to interact with arises.
Therefore, there is a need for a more efficient and robust testing method during software application run-time.